Termination w.r.t. Q proof of /tmp/tmp0yEL3o/ExSec11_1_Luc02a

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

SQR(ok(X)) → SQR(X)
PROPER(dbl(X)) → PROPER(X)
PROPER(dbl(X)) → DBL(proper(X))
ACTIVE(half(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
PROPER(add(X1, X2)) → ADD(proper(X1), proper(X2))
ACTIVE(recip(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → CONS(active(X1), X2)
ADD(mark(X1), X2) → ADD(X1, X2)
DBL(mark(X)) → DBL(X)
PROPER(first(X1, X2)) → PROPER(X2)
HALF(mark(X)) → HALF(X)
ACTIVE(first(s(X), cons(Y, Z))) → FIRST(X, Z)
RECIP(ok(X)) → RECIP(X)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X2)
SQR(mark(X)) → SQR(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(sqr(X)) → SQR(active(X))
TERMS(mark(X)) → TERMS(X)
ACTIVE(terms(N)) → S(N)
ADD(ok(X1), ok(X2)) → ADD(X1, X2)
ACTIVE(add(X1, X2)) → ADD(active(X1), X2)
PROPER(half(X)) → HALF(proper(X))
PROPER(s(X)) → S(proper(X))
PROPER(recip(X)) → PROPER(X)
ACTIVE(terms(X)) → ACTIVE(X)
PROPER(terms(X)) → PROPER(X)
FIRST(mark(X1), X2) → FIRST(X1, X2)
ACTIVE(terms(N)) → RECIP(sqr(N))
ACTIVE(dbl(s(X))) → DBL(X)
ACTIVE(s(X)) → ACTIVE(X)
PROPER(sqr(X)) → SQR(proper(X))
ACTIVE(recip(X)) → RECIP(active(X))
ACTIVE(first(X1, X2)) → ACTIVE(X1)
ACTIVE(first(X1, X2)) → ACTIVE(X2)
ACTIVE(terms(N)) → TERMS(s(N))
FIRST(X1, mark(X2)) → FIRST(X1, X2)
DBL(ok(X)) → DBL(X)
S(ok(X)) → S(X)
ACTIVE(dbl(s(X))) → S(dbl(X))
ACTIVE(first(X1, X2)) → FIRST(active(X1), X2)
ACTIVE(first(X1, X2)) → FIRST(X1, active(X2))
CONS(mark(X1), X2) → CONS(X1, X2)
ACTIVE(half(X)) → HALF(active(X))
ACTIVE(add(s(X), Y)) → ADD(X, Y)
ACTIVE(sqr(s(X))) → S(add(sqr(X), dbl(X)))
ACTIVE(dbl(X)) → ACTIVE(X)
TOP(mark(X)) → PROPER(X)
ACTIVE(add(s(X), Y)) → S(add(X, Y))
PROPER(add(X1, X2)) → PROPER(X1)
ACTIVE(terms(N)) → SQR(N)
FIRST(ok(X1), ok(X2)) → FIRST(X1, X2)
PROPER(first(X1, X2)) → FIRST(proper(X1), proper(X2))
ADD(X1, mark(X2)) → ADD(X1, X2)
TOP(ok(X)) → ACTIVE(X)
ACTIVE(half(s(s(X)))) → HALF(X)
ACTIVE(half(s(s(X)))) → S(half(X))
HALF(ok(X)) → HALF(X)
ACTIVE(dbl(X)) → DBL(active(X))
PROPER(s(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(terms(X)) → TERMS(proper(X))
TOP(ok(X)) → TOP(active(X))
S(mark(X)) → S(X)
PROPER(cons(X1, X2)) → CONS(proper(X1), proper(X2))
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
ACTIVE(dbl(s(X))) → S(s(dbl(X)))
PROPER(first(X1, X2)) → PROPER(X1)
ACTIVE(add(X1, X2)) → ACTIVE(X2)
TERMS(ok(X)) → TERMS(X)
PROPER(sqr(X)) → PROPER(X)
ACTIVE(sqr(s(X))) → ADD(sqr(X), dbl(X))
ACTIVE(terms(N)) → CONS(recip(sqr(N)), terms(s(N)))
ACTIVE(terms(X)) → TERMS(active(X))
TOP(mark(X)) → TOP(proper(X))
ACTIVE(sqr(s(X))) → DBL(X)
ACTIVE(add(X1, X2)) → ADD(X1, active(X2))
PROPER(recip(X)) → RECIP(proper(X))
ACTIVE(first(s(X), cons(Y, Z))) → CONS(Y, first(X, Z))
RECIP(mark(X)) → RECIP(X)
ACTIVE(sqr(X)) → ACTIVE(X)
PROPER(half(X)) → PROPER(X)
ACTIVE(sqr(s(X))) → SQR(X)
ACTIVE(s(X)) → S(active(X))

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

SQR(ok(X)) → SQR(X)
PROPER(dbl(X)) → PROPER(X)
PROPER(dbl(X)) → DBL(proper(X))
ACTIVE(half(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
PROPER(add(X1, X2)) → ADD(proper(X1), proper(X2))
ACTIVE(recip(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → CONS(active(X1), X2)
ADD(mark(X1), X2) → ADD(X1, X2)
DBL(mark(X)) → DBL(X)
PROPER(first(X1, X2)) → PROPER(X2)
HALF(mark(X)) → HALF(X)
ACTIVE(first(s(X), cons(Y, Z))) → FIRST(X, Z)
RECIP(ok(X)) → RECIP(X)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X2)
SQR(mark(X)) → SQR(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(sqr(X)) → SQR(active(X))
TERMS(mark(X)) → TERMS(X)
ACTIVE(terms(N)) → S(N)
ADD(ok(X1), ok(X2)) → ADD(X1, X2)
ACTIVE(add(X1, X2)) → ADD(active(X1), X2)
PROPER(half(X)) → HALF(proper(X))
PROPER(s(X)) → S(proper(X))
PROPER(recip(X)) → PROPER(X)
ACTIVE(terms(X)) → ACTIVE(X)
PROPER(terms(X)) → PROPER(X)
FIRST(mark(X1), X2) → FIRST(X1, X2)
ACTIVE(terms(N)) → RECIP(sqr(N))
ACTIVE(dbl(s(X))) → DBL(X)
ACTIVE(s(X)) → ACTIVE(X)
PROPER(sqr(X)) → SQR(proper(X))
ACTIVE(recip(X)) → RECIP(active(X))
ACTIVE(first(X1, X2)) → ACTIVE(X1)
ACTIVE(first(X1, X2)) → ACTIVE(X2)
ACTIVE(terms(N)) → TERMS(s(N))
FIRST(X1, mark(X2)) → FIRST(X1, X2)
DBL(ok(X)) → DBL(X)
S(ok(X)) → S(X)
ACTIVE(dbl(s(X))) → S(dbl(X))
ACTIVE(first(X1, X2)) → FIRST(active(X1), X2)
ACTIVE(first(X1, X2)) → FIRST(X1, active(X2))
CONS(mark(X1), X2) → CONS(X1, X2)
ACTIVE(half(X)) → HALF(active(X))
ACTIVE(add(s(X), Y)) → ADD(X, Y)
ACTIVE(sqr(s(X))) → S(add(sqr(X), dbl(X)))
ACTIVE(dbl(X)) → ACTIVE(X)
TOP(mark(X)) → PROPER(X)
ACTIVE(add(s(X), Y)) → S(add(X, Y))
PROPER(add(X1, X2)) → PROPER(X1)
ACTIVE(terms(N)) → SQR(N)
FIRST(ok(X1), ok(X2)) → FIRST(X1, X2)
PROPER(first(X1, X2)) → FIRST(proper(X1), proper(X2))
ADD(X1, mark(X2)) → ADD(X1, X2)
TOP(ok(X)) → ACTIVE(X)
ACTIVE(half(s(s(X)))) → HALF(X)
ACTIVE(half(s(s(X)))) → S(half(X))
HALF(ok(X)) → HALF(X)
ACTIVE(dbl(X)) → DBL(active(X))
PROPER(s(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(terms(X)) → TERMS(proper(X))
TOP(ok(X)) → TOP(active(X))
S(mark(X)) → S(X)
PROPER(cons(X1, X2)) → CONS(proper(X1), proper(X2))
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
ACTIVE(dbl(s(X))) → S(s(dbl(X)))
PROPER(first(X1, X2)) → PROPER(X1)
ACTIVE(add(X1, X2)) → ACTIVE(X2)
TERMS(ok(X)) → TERMS(X)
PROPER(sqr(X)) → PROPER(X)
ACTIVE(sqr(s(X))) → ADD(sqr(X), dbl(X))
ACTIVE(terms(N)) → CONS(recip(sqr(N)), terms(s(N)))
ACTIVE(terms(X)) → TERMS(active(X))
TOP(mark(X)) → TOP(proper(X))
ACTIVE(sqr(s(X))) → DBL(X)
ACTIVE(add(X1, X2)) → ADD(X1, active(X2))
PROPER(recip(X)) → RECIP(proper(X))
ACTIVE(first(s(X), cons(Y, Z))) → CONS(Y, first(X, Z))
RECIP(mark(X)) → RECIP(X)
ACTIVE(sqr(X)) → ACTIVE(X)
PROPER(half(X)) → PROPER(X)
ACTIVE(sqr(s(X))) → SQR(X)
ACTIVE(s(X)) → S(active(X))

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 12 SCCs with 40 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

HALF(ok(X)) → HALF(X)
HALF(mark(X)) → HALF(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

HALF(ok(X)) → HALF(X)
HALF(mark(X)) → HALF(X)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

HALF(ok(X)) → HALF(X)
The graph contains the following edges 1 > 1
HALF(mark(X)) → HALF(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(ok(X1), ok(X2)) → FIRST(X1, X2)
FIRST(mark(X1), X2) → FIRST(X1, X2)
FIRST(X1, mark(X2)) → FIRST(X1, X2)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FIRST(ok(X1), ok(X2)) → FIRST(X1, X2)
FIRST(X1, mark(X2)) → FIRST(X1, X2)
FIRST(mark(X1), X2) → FIRST(X1, X2)

From the DPs we obtained the following set of size-change graphs:

FIRST(ok(X1), ok(X2)) → FIRST(X1, X2)
The graph contains the following edges 1 > 1, 2 > 2
FIRST(mark(X1), X2) → FIRST(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
FIRST(X1, mark(X2)) → FIRST(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL(mark(X)) → DBL(X)
DBL(ok(X)) → DBL(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

DBL(ok(X)) → DBL(X)
DBL(mark(X)) → DBL(X)

From the DPs we obtained the following set of size-change graphs:

DBL(mark(X)) → DBL(X)
The graph contains the following edges 1 > 1
DBL(ok(X)) → DBL(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ADD(ok(X1), ok(X2)) → ADD(X1, X2)
ADD(X1, mark(X2)) → ADD(X1, X2)
ADD(mark(X1), X2) → ADD(X1, X2)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ADD(ok(X1), ok(X2)) → ADD(X1, X2)
ADD(X1, mark(X2)) → ADD(X1, X2)
ADD(mark(X1), X2) → ADD(X1, X2)

From the DPs we obtained the following set of size-change graphs:

ADD(ok(X1), ok(X2)) → ADD(X1, X2)
The graph contains the following edges 1 > 1, 2 > 2
ADD(X1, mark(X2)) → ADD(X1, X2)
The graph contains the following edges 1 >= 1, 2 > 2
ADD(mark(X1), X2) → ADD(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S(ok(X)) → S(X)
S(mark(X)) → S(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S(ok(X)) → S(X)
S(mark(X)) → S(X)

From the DPs we obtained the following set of size-change graphs:

S(ok(X)) → S(X)
The graph contains the following edges 1 > 1
S(mark(X)) → S(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQR(ok(X)) → SQR(X)
SQR(mark(X)) → SQR(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQR(ok(X)) → SQR(X)
SQR(mark(X)) → SQR(X)

From the DPs we obtained the following set of size-change graphs:

SQR(ok(X)) → SQR(X)
The graph contains the following edges 1 > 1
SQR(mark(X)) → SQR(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RECIP(ok(X)) → RECIP(X)
RECIP(mark(X)) → RECIP(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RECIP(ok(X)) → RECIP(X)
RECIP(mark(X)) → RECIP(X)

From the DPs we obtained the following set of size-change graphs:

RECIP(ok(X)) → RECIP(X)
The graph contains the following edges 1 > 1
RECIP(mark(X)) → RECIP(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS(mark(X1), X2) → CONS(X1, X2)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS(mark(X1), X2) → CONS(X1, X2)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)

From the DPs we obtained the following set of size-change graphs:

CONS(mark(X1), X2) → CONS(X1, X2)
The graph contains the following edges 1 > 1, 2 >= 2
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TERMS(ok(X)) → TERMS(X)
TERMS(mark(X)) → TERMS(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TERMS(ok(X)) → TERMS(X)
TERMS(mark(X)) → TERMS(X)

From the DPs we obtained the following set of size-change graphs:

TERMS(ok(X)) → TERMS(X)
The graph contains the following edges 1 > 1
TERMS(mark(X)) → TERMS(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER(dbl(X)) → PROPER(X)
PROPER(first(X1, X2)) → PROPER(X2)
PROPER(s(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(first(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(add(X1, X2)) → PROPER(X1)
PROPER(recip(X)) → PROPER(X)
PROPER(half(X)) → PROPER(X)
PROPER(sqr(X)) → PROPER(X)
PROPER(terms(X)) → PROPER(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER(dbl(X)) → PROPER(X)
PROPER(first(X1, X2)) → PROPER(X2)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(s(X)) → PROPER(X)
PROPER(add(X1, X2)) → PROPER(X2)
PROPER(first(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(recip(X)) → PROPER(X)
PROPER(add(X1, X2)) → PROPER(X1)
PROPER(terms(X)) → PROPER(X)
PROPER(sqr(X)) → PROPER(X)
PROPER(half(X)) → PROPER(X)

From the DPs we obtained the following set of size-change graphs:

PROPER(dbl(X)) → PROPER(X)
The graph contains the following edges 1 > 1
PROPER(first(X1, X2)) → PROPER(X2)
The graph contains the following edges 1 > 1
PROPER(s(X)) → PROPER(X)
The graph contains the following edges 1 > 1
PROPER(cons(X1, X2)) → PROPER(X1)
The graph contains the following edges 1 > 1
PROPER(add(X1, X2)) → PROPER(X2)
The graph contains the following edges 1 > 1
PROPER(first(X1, X2)) → PROPER(X1)
The graph contains the following edges 1 > 1
PROPER(cons(X1, X2)) → PROPER(X2)
The graph contains the following edges 1 > 1
PROPER(add(X1, X2)) → PROPER(X1)
The graph contains the following edges 1 > 1
PROPER(recip(X)) → PROPER(X)
The graph contains the following edges 1 > 1
PROPER(half(X)) → PROPER(X)
The graph contains the following edges 1 > 1
PROPER(sqr(X)) → PROPER(X)
The graph contains the following edges 1 > 1
PROPER(terms(X)) → PROPER(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(half(X)) → ACTIVE(X)
ACTIVE(dbl(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(first(X1, X2)) → ACTIVE(X1)
ACTIVE(recip(X)) → ACTIVE(X)
ACTIVE(terms(X)) → ACTIVE(X)
ACTIVE(first(X1, X2)) → ACTIVE(X2)
ACTIVE(sqr(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesProof

              ↳ QDP

                ↳ QDPSizeChangeProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE(half(X)) → ACTIVE(X)
ACTIVE(add(X1, X2)) → ACTIVE(X1)
ACTIVE(dbl(X)) → ACTIVE(X)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(add(X1, X2)) → ACTIVE(X2)
ACTIVE(terms(X)) → ACTIVE(X)
ACTIVE(recip(X)) → ACTIVE(X)
ACTIVE(first(X1, X2)) → ACTIVE(X1)
ACTIVE(first(X1, X2)) → ACTIVE(X2)
ACTIVE(sqr(X)) → ACTIVE(X)

From the DPs we obtained the following set of size-change graphs:

ACTIVE(half(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1
ACTIVE(dbl(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1
ACTIVE(add(X1, X2)) → ACTIVE(X1)
The graph contains the following edges 1 > 1
ACTIVE(s(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1
ACTIVE(add(X1, X2)) → ACTIVE(X2)
The graph contains the following edges 1 > 1
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
The graph contains the following edges 1 > 1
ACTIVE(first(X1, X2)) → ACTIVE(X1)
The graph contains the following edges 1 > 1
ACTIVE(recip(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1
ACTIVE(terms(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1
ACTIVE(first(X1, X2)) → ACTIVE(X2)
The graph contains the following edges 1 > 1
ACTIVE(sqr(X)) → ACTIVE(X)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesReductionPairsProof

Q DP problem:
The TRS P consists of the following rules:

TOP(mark(X)) → TOP(proper(X))
TOP(ok(X)) → TOP(active(X))

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
terms(mark(X)) → mark(terms(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
recip(mark(X)) → mark(recip(X))
sqr(mark(X)) → mark(sqr(X))
s(mark(X)) → mark(s(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
dbl(mark(X)) → mark(dbl(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
half(mark(X)) → mark(half(X))
proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
terms(ok(X)) → ok(terms(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
recip(ok(X)) → ok(recip(X))
sqr(ok(X)) → ok(sqr(X))
s(ok(X)) → ok(s(X))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
dbl(ok(X)) → ok(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
half(ok(X)) → ok(half(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

No dependency pairs are removed.

No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(active(x₁)) = 2·x₁
POL(add(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(dbl(x₁)) = x₁
POL(first(x₁, x₂)) = x₁ + x₂
POL(half(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = 2·x₁
POL(proper(x₁)) = x₁
POL(recip(x₁)) = x₁
POL(s(x₁)) = x₁
POL(sqr(x₁)) = x₁
POL(terms(x₁)) = 2·x₁

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesReductionPairsProof

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

TOP(mark(X)) → TOP(proper(X))
TOP(ok(X)) → TOP(active(X))

The TRS R consists of the following rules:

proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
half(mark(X)) → mark(half(X))
half(ok(X)) → ok(half(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
dbl(mark(X)) → mark(dbl(X))
dbl(ok(X)) → ok(dbl(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
s(mark(X)) → mark(s(X))
s(ok(X)) → ok(s(X))
sqr(mark(X)) → mark(sqr(X))
sqr(ok(X)) → ok(sqr(X))
recip(mark(X)) → mark(recip(X))
recip(ok(X)) → ok(recip(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
terms(mark(X)) → mark(terms(X))
terms(ok(X)) → ok(terms(X))
active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(mark(X)) → TOP(proper(X))

The remaining pairs can at least be oriented weakly.

TOP(ok(X)) → TOP(active(X))

Used ordering: Combined order from the following AFS and order.
TOP(x1) = TOP(x1)
mark(x1) = mark(x1)
proper(x1) = x1
ok(x1) = x1
active(x1) = x1
s(x1) = s(x1)
sqr(x1) = sqr(x1)
recip(x1) = x1
cons(x1, x2) = x1
first(x1, x2) = first(x1, x2)
dbl(x1) = dbl(x1)
add(x1, x2) = add(x1, x2)
0 = 0
half(x1) = half(x1)
nil = nil
terms(x1) = terms(x1)

Recursive path order with status [2].
Quasi-Precedence:

half₁ > [s₁, first₂] > mark₁ > TOP₁
half₁ > [s₁, first₂] > 0
half₁ > [s₁, first₂] > nil
terms₁ > [sqr₁, dbl₁] > add₂ > [s₁, first₂] > mark₁ > TOP₁
terms₁ > [sqr₁, dbl₁] > add₂ > [s₁, first₂] > 0
terms₁ > [sqr₁, dbl₁] > add₂ > [s₁, first₂] > nil

Status:

add₂: multiset
half₁: multiset
sqr₁: [1]
dbl₁: [1]
mark₁: [1]
TOP₁: multiset
s₁: [1]
first₂: [1,2]
0: multiset
nil: multiset
terms₁: [1]

The following usable rules [17] were oriented:

proper(s(X)) → s(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(recip(X)) → recip(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(0) → ok(0)
half(ok(X)) → ok(half(X))
half(mark(X)) → mark(half(X))
proper(half(X)) → half(proper(X))
proper(nil) → ok(nil)
dbl(mark(X)) → mark(dbl(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
first(mark(X1), X2) → mark(first(X1, X2))
proper(terms(X)) → terms(proper(X))
active(dbl(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(add(0, X)) → mark(X)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(first(0, X)) → mark(nil)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(half(0)) → mark(0)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(s(s(X)))) → mark(s(half(X)))
active(half(s(0))) → mark(0)
active(terms(X)) → terms(active(X))
active(half(dbl(X))) → mark(X)
active(recip(X)) → recip(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(s(X)) → s(active(X))
active(sqr(X)) → sqr(active(X))
dbl(ok(X)) → ok(dbl(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
s(mark(X)) → mark(s(X))
s(ok(X)) → ok(s(X))
sqr(mark(X)) → mark(sqr(X))
sqr(ok(X)) → ok(sqr(X))
recip(mark(X)) → mark(recip(X))
recip(ok(X)) → ok(recip(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
terms(mark(X)) → mark(terms(X))
terms(ok(X)) → ok(terms(X))
active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesReductionPairsProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ UsableRulesReductionPairsProof

Q DP problem:
The TRS P consists of the following rules:

TOP(ok(X)) → TOP(active(X))

The TRS R consists of the following rules:

proper(terms(X)) → terms(proper(X))
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(recip(X)) → recip(proper(X))
proper(sqr(X)) → sqr(proper(X))
proper(s(X)) → s(proper(X))
proper(0) → ok(0)
proper(add(X1, X2)) → add(proper(X1), proper(X2))
proper(dbl(X)) → dbl(proper(X))
proper(first(X1, X2)) → first(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(half(X)) → half(proper(X))
half(mark(X)) → mark(half(X))
half(ok(X)) → ok(half(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
dbl(mark(X)) → mark(dbl(X))
dbl(ok(X)) → ok(dbl(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
s(mark(X)) → mark(s(X))
s(ok(X)) → ok(s(X))
sqr(mark(X)) → mark(sqr(X))
sqr(ok(X)) → ok(sqr(X))
recip(mark(X)) → mark(recip(X))
recip(ok(X)) → ok(recip(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
terms(mark(X)) → mark(terms(X))
terms(ok(X)) → ok(terms(X))
active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(0)) → mark(0)
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(0)) → mark(0)
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(0, X)) → mark(X)
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))

active(sqr(0)) → mark(0)
active(dbl(0)) → mark(0)
active(add(0, X)) → mark(X)
active(half(0)) → mark(0)
active(half(s(0))) → mark(0)

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 1
POL(TOP(x₁)) = x₁
POL(active(x₁)) = 2·x₁
POL(add(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(dbl(x₁)) = x₁
POL(first(x₁, x₂)) = x₁ + x₂
POL(half(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 2
POL(ok(x₁)) = 2·x₁
POL(recip(x₁)) = x₁
POL(s(x₁)) = x₁
POL(sqr(x₁)) = x₁
POL(terms(x₁)) = 2·x₁

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesReductionPairsProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ UsableRulesReductionPairsProof

                      ↳ QDP

                        ↳ UsableRulesReductionPairsProof

Q DP problem:
The TRS P consists of the following rules:

TOP(ok(X)) → TOP(active(X))

The TRS R consists of the following rules:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(0, X)) → mark(nil)
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
active(half(X)) → half(active(X))
half(mark(X)) → mark(half(X))
half(ok(X)) → ok(half(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
dbl(mark(X)) → mark(dbl(X))
dbl(ok(X)) → ok(dbl(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
s(mark(X)) → mark(s(X))
s(ok(X)) → ok(s(X))
sqr(mark(X)) → mark(sqr(X))
sqr(ok(X)) → ok(sqr(X))
recip(mark(X)) → mark(recip(X))
recip(ok(X)) → ok(recip(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
terms(mark(X)) → mark(terms(X))
terms(ok(X)) → ok(terms(X))

TOP(ok(X)) → TOP(active(X))

The following rules are removed from R:

active(terms(N)) → mark(cons(recip(sqr(N)), terms(s(N))))
active(first(0, X)) → mark(nil)
active(half(s(s(X)))) → mark(s(half(X)))
active(half(dbl(X))) → mark(X)
active(terms(X)) → terms(active(X))
active(half(X)) → half(active(X))
half(ok(X)) → ok(half(X))
first(ok(X1), ok(X2)) → ok(first(X1, X2))
add(ok(X1), ok(X2)) → ok(add(X1, X2))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
terms(ok(X)) → ok(terms(X))

Used ordering: POLO with Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(active(x₁)) = 2·x₁
POL(add(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(dbl(x₁)) = x₁
POL(first(x₁, x₂)) = 2·x₁ + 2·x₂
POL(half(x₁)) = 1 + 2·x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = 2 + 2·x₁
POL(recip(x₁)) = x₁
POL(s(x₁)) = x₁
POL(sqr(x₁)) = x₁
POL(terms(x₁)) = 1 + 2·x₁

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ UsableRulesReductionPairsProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ UsableRulesReductionPairsProof

                      ↳ QDP

                        ↳ UsableRulesReductionPairsProof

                          ↳ QDP

                            ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(sqr(s(X))) → mark(s(add(sqr(X), dbl(X))))
active(dbl(s(X))) → mark(s(s(dbl(X))))
active(add(s(X), Y)) → mark(s(add(X, Y)))
active(first(s(X), cons(Y, Z))) → mark(cons(Y, first(X, Z)))
active(cons(X1, X2)) → cons(active(X1), X2)
active(recip(X)) → recip(active(X))
active(sqr(X)) → sqr(active(X))
active(s(X)) → s(active(X))
active(add(X1, X2)) → add(active(X1), X2)
active(add(X1, X2)) → add(X1, active(X2))
active(dbl(X)) → dbl(active(X))
active(first(X1, X2)) → first(active(X1), X2)
active(first(X1, X2)) → first(X1, active(X2))
half(mark(X)) → mark(half(X))
first(mark(X1), X2) → mark(first(X1, X2))
first(X1, mark(X2)) → mark(first(X1, X2))
dbl(mark(X)) → mark(dbl(X))
dbl(ok(X)) → ok(dbl(X))
add(mark(X1), X2) → mark(add(X1, X2))
add(X1, mark(X2)) → mark(add(X1, X2))
s(mark(X)) → mark(s(X))
s(ok(X)) → ok(s(X))
sqr(mark(X)) → mark(sqr(X))
sqr(ok(X)) → ok(sqr(X))
recip(mark(X)) → mark(recip(X))
recip(ok(X)) → ok(recip(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
terms(mark(X)) → mark(terms(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.